package com.christina.engine.state.model;

import com.christina.engine.state.ConversationState;
import lombok.Builder;
import lombok.Data;
import java.time.LocalDateTime;
import java.util.Map;

/**
 * 状态转换结果
 * 包含状态转换的详细信息
 * 
 * @author Christina
 */
@Data
@Builder
public class StateTransitionResult {
    
    /**
     * 是否成功
     */
    private Boolean success;
    
    /**
     * 下一个状态
     */
    private ConversationState nextState;
    
    /**
     * 响应消息
     */
    private String responseMessage;
    
    /**
     * 转换原因
     */
    private String reason;
    
    /**
     * 错误信息
     */
    private String errorMessage;
    
    /**
     * 是否需要用户输入
     */
    private Boolean needsUserInput;
    
    /**
     * 是否应该结束对话
     */
    private Boolean shouldEndConversation;
    
    /**
     * 转换时间
     */
    private LocalDateTime transitionTime;
    
    /**
     * 结果数据
     */
    private Map<String, Object> resultData;
    
    /**
     * 状态数据更新
     */
    private Map<String, Object> stateDataUpdates;
    
    /**
     * 延迟时间（毫秒）
     */
    private Long delayMillis;
    
    /**
     * 是否需要重试
     */
    private Boolean needsRetry;
    
    /**
     * 重试延迟时间（毫秒）
     */
    private Long retryDelayMillis;
    
    /**
     * 优先级
     */
    private Integer priority;
    
    /**
     * 元数据
     */
    private Map<String, Object> metadata;
    
    /**
     * 创建成功的转换结果
     * 
     * @param nextState 下一个状态
     * @param responseMessage 响应消息
     * @return 转换结果
     */
    public static StateTransitionResult success(ConversationState nextState, String responseMessage) {
        return StateTransitionResult.builder()
                .success(true)
                .nextState(nextState)
                .responseMessage(responseMessage)
                .transitionTime(LocalDateTime.now())
                .needsUserInput(false)
                .shouldEndConversation(false)
                .needsRetry(false)
                .build();
    }
    
    /**
     * 创建成功的转换结果（保持当前状态）
     * 
     * @param responseMessage 响应消息
     * @return 转换结果
     */
    public static StateTransitionResult stayInCurrentState(String responseMessage) {
        return StateTransitionResult.builder()
                .success(true)
                .nextState(null) // null表示保持当前状态
                .responseMessage(responseMessage)
                .transitionTime(LocalDateTime.now())
                .needsUserInput(true)
                .shouldEndConversation(false)
                .needsRetry(false)
                .build();
    }
    
    /**
     * 创建需要用户输入的转换结果
     * 
     * @param responseMessage 响应消息
     * @return 转换结果
     */
    public static StateTransitionResult waitForUserInput(String responseMessage) {
        return StateTransitionResult.builder()
                .success(true)
                .nextState(null)
                .responseMessage(responseMessage)
                .transitionTime(LocalDateTime.now())
                .needsUserInput(true)
                .shouldEndConversation(false)
                .needsRetry(false)
                .build();
    }
    
    /**
     * 创建失败的转换结果
     * 
     * @param errorMessage 错误信息
     * @return 转换结果
     */
    public static StateTransitionResult failure(String errorMessage) {
        return StateTransitionResult.builder()
                .success(false)
                .errorMessage(errorMessage)
                .transitionTime(LocalDateTime.now())
                .needsUserInput(false)
                .shouldEndConversation(false)
                .needsRetry(false)
                .build();
    }
    
    /**
     * 创建需要重试的转换结果
     * 
     * @param errorMessage 错误信息
     * @param retryDelayMillis 重试延迟时间
     * @return 转换结果
     */
    public static StateTransitionResult retry(String errorMessage, Long retryDelayMillis) {
        return StateTransitionResult.builder()
                .success(false)
                .errorMessage(errorMessage)
                .transitionTime(LocalDateTime.now())
                .needsUserInput(false)
                .shouldEndConversation(false)
                .needsRetry(true)
                .retryDelayMillis(retryDelayMillis)
                .build();
    }
    
    /**
     * 创建结束对话的转换结果
     * 
     * @param responseMessage 响应消息
     * @return 转换结果
     */
    public static StateTransitionResult endConversation(String responseMessage) {
        return StateTransitionResult.builder()
                .success(true)
                .responseMessage(responseMessage)
                .transitionTime(LocalDateTime.now())
                .needsUserInput(false)
                .shouldEndConversation(true)
                .needsRetry(false)
                .build();
    }
    
    /**
     * 创建延迟转换的结果
     * 
     * @param nextState 下一个状态
     * @param responseMessage 响应消息
     * @param delayMillis 延迟时间
     * @return 转换结果
     */
    public static StateTransitionResult delayedTransition(ConversationState nextState, 
                                                        String responseMessage, 
                                                        Long delayMillis) {
        return StateTransitionResult.builder()
                .success(true)
                .nextState(nextState)
                .responseMessage(responseMessage)
                .transitionTime(LocalDateTime.now())
                .delayMillis(delayMillis)
                .needsUserInput(false)
                .shouldEndConversation(false)
                .needsRetry(false)
                .build();
    }
    
    /**
     * 检查是否为成功的转换
     * 
     * @return 是否成功
     */
    public boolean isSuccessful() {
        return Boolean.TRUE.equals(success);
    }
    
    /**
     * 检查是否需要状态转换
     * 
     * @return 是否需要转换
     */
    public boolean hasStateTransition() {
        return nextState != null;
    }
    
    /**
     * 检查是否有响应消息
     * 
     * @return 是否有响应消息
     */
    public boolean hasResponseMessage() {
        return responseMessage != null && !responseMessage.trim().isEmpty();
    }
    
    /**
     * 检查是否有延迟
     * 
     * @return 是否有延迟
     */
    public boolean hasDelay() {
        return delayMillis != null && delayMillis > 0;
    }
    
    /**
     * 检查是否需要重试
     * 
     * @return 是否需要重试
     */
    public boolean shouldRetry() {
        return Boolean.TRUE.equals(needsRetry);
    }
    
    /**
     * 检查是否应该结束对话
     * 
     * @return 是否应该结束对话
     */
    public boolean shouldEnd() {
        return Boolean.TRUE.equals(shouldEndConversation);
    }
    
    /**
     * 检查是否需要用户输入
     * 
     * @return 是否需要用户输入
     */
    public boolean requiresUserInput() {
        return Boolean.TRUE.equals(needsUserInput);
    }
    
    /**
     * 添加结果数据
     * 
     * @param key 数据键
     * @param value 数据值
     * @return 当前实例
     */
    public StateTransitionResult addResultData(String key, Object value) {
        if (resultData == null) {
            resultData = new java.util.HashMap<>();
        }
        resultData.put(key, value);
        return this;
    }
    
    /**
     * 添加状态数据更新
     * 
     * @param key 数据键
     * @param value 数据值
     * @return 当前实例
     */
    public StateTransitionResult addStateDataUpdate(String key, Object value) {
        if (stateDataUpdates == null) {
            stateDataUpdates = new java.util.HashMap<>();
        }
        stateDataUpdates.put(key, value);
        return this;
    }
    
    /**
     * 添加元数据
     * 
     * @param key 元数据键
     * @param value 元数据值
     * @return 当前实例
     */
    public StateTransitionResult addMetadata(String key, Object value) {
        if (metadata == null) {
            metadata = new java.util.HashMap<>();
        }
        metadata.put(key, value);
        return this;
    }
}